import type { TableData } from '@/services/wordParserService'

/**
 * 将Word解析的表格数据转换为IFormTable组件可用的格式
 * @param wordTables Word解析的表格数据数组
 * @returns 转换后的表格数据
 */
export function convertWordTablesToIFormTable(wordTables: TableData[]) {
  if (!wordTables || wordTables.length === 0) {
    return []
  }

  return wordTables.map((table, tableIndex) => {
    // 提取列配置
    const columns = extractColumnsFromTable(table)

    // 提取行数据
    const tableData = extractTableData(table)


    return {
      id: `table_${tableIndex}`,
      name: `表格 ${tableIndex + 1}`,
      columns,
      tableData,
      // 表格配置
      border: true,
      stripe: false,
      size: 'default',
      showHeader: false,
      highlightCurrentRow: false,
      emptyText: '暂无数据',
      showSummary: false,
      // 样式配置
      width: '100%',
      height: '100%'
    }
  })
}

/**
 * 计算表格的实际最大列数，考虑跨列数
 * @param table Word表格数据
 * @returns 最大列数
 */
function calculateMaxColumns(table: TableData): number {
  if (!table.rows || table.rows.length === 0) {
    return 0
  }

  let maxColumns = 0

  table.rows.forEach(row => {
    let currentColumnCount = 0

    row.forEach(cell => {
      // 每个单元格至少占用1列，如果有colspan则占用colspan列
      const cellColumns = cell.colspan || 1
      currentColumnCount += cellColumns
    })

    maxColumns = Math.max(maxColumns, currentColumnCount)
  })

  return maxColumns
}

/**
 * 从表格中提取列配置
 * @param table Word表格数据
 * @returns 列配置数组
 */
function extractColumnsFromTable(table: TableData) {
  if (!table.rows || table.rows.length === 0) {
    return []
  }

  // 使用第一行作为表头
  const firstRow = table.rows[0]
  const maxColumns = calculateMaxColumns(table)

  const columns = []

  for (let i = 0; i < maxColumns; i++) {
    const headerCell = firstRow[i]
    const columnLabel = headerCell?.content || `列 ${i + 1}`

    // 优先使用从Word表格中提取的列宽
    const columnWidth = getColumnWidth(table, i, columnLabel)

    columns.push({
      prop: `col_${i}`,
      label: columnLabel,
      width: columnWidth,
      sortable: false,
      showOverflowTooltip: false,
      align: 'left' as const
    })
  }

  return columns
}

/**
 * 获取列宽度，优先使用Word表格中的列宽信息
 * @param table Word表格数据
 * @param columnIndex 列索引
 * @param columnLabel 列标签
 * @returns 列宽度
 */
function getColumnWidth(table: TableData, columnIndex: number, columnLabel: string): number {
  // 优先使用从Word表格中提取的列宽信息
  if (table.columnWidths && table.columnWidths.length > columnIndex) {
    const widthStr = table.columnWidths[columnIndex]
    if (widthStr && widthStr !== 'auto') {
      // 解析宽度值，支持px、%、pt等单位
      const widthMatch = widthStr.match(/(\d+(?:\.\d+)?)(px|%|pt|em|rem)?/)
      if (widthMatch) {
        const value = parseFloat(widthMatch[1])
        const unit = widthMatch[2] || 'px'
        
        // 转换为像素值（简化处理，实际项目中可能需要更复杂的转换）
        if (unit === 'px') {
          return Math.max(80, Math.min(300, value)) // 限制在合理范围内
        } else if (unit === '%') {
          return Math.max(80, Math.min(300, value * 2)) // 百分比转换为像素的简化处理
        } else if (unit === 'pt') {
          return Math.max(80, Math.min(300, value * 1.33)) // pt转px的简化处理
        } else {
          return Math.max(80, Math.min(300, value))
        }
      }
    }
  }

  // 检查第一行对应单元格的宽度
  if (table.rows && table.rows.length > 0) {
    const firstRow = table.rows[0]
    const headerCell = firstRow[columnIndex]
    if (headerCell?.width) {
      const widthMatch = headerCell.width.match(/(\d+(?:\.\d+)?)(px|%|pt|em|rem)?/)
      if (widthMatch) {
        const value = parseFloat(widthMatch[1])
        const unit = widthMatch[2] || 'px'
        
        if (unit === 'px') {
          return Math.max(80, Math.min(300, value))
        } else if (unit === '%') {
          return Math.max(80, Math.min(300, value * 2))
        } else if (unit === 'pt') {
          return Math.max(80, Math.min(300, value * 1.33))
        } else {
          return Math.max(80, Math.min(300, value))
        }
      }
    }
  }

  // 回退到基于内容长度的计算
  return calculateColumnWidth(columnLabel)
}

/**
 * 从表格中提取行数据
 * @param table Word表格数据
 * @returns 行数据数组
 */
function extractTableData(table: TableData) {
  if (!table.rows || table.rows.length === 0) {
    return []
  }

  const maxColumns = calculateMaxColumns(table)

  return table.rows.map((row, rowIndex) => {
    const rowData: Record<string, string | { content: string; rowspan: number; colspan: number }> = {
      // id: `row_${rowIndex}`
    }

    for (let i = 0; i < maxColumns; i++) {
      const cell = row[i]
      const cellContent = cell?.content || ''

      // 处理合并单元格 - 统一格式，包含content、rowspan、colspan
      if (cell?.rowspan && cell.rowspan > 1) {
        rowData[`col_${i}`] = {
          content: cellContent,
          rowspan: cell.rowspan,
          colspan: cell.colspan || 1
        }
      } else if (cell?.colspan && cell.colspan > 1) {
        rowData[`col_${i}`] = {
          content: cellContent,
          rowspan: 1,
          colspan: cell.colspan
        }
      } else if (cell?.rowspan || cell?.colspan) {
        // 即使rowspan或colspan为1，也保持对象格式以保持一致性
        rowData[`col_${i}`] = {
          content: cellContent,
          rowspan: cell.rowspan || 1,
          colspan: cell.colspan || 1
        }
      } else {
        // 普通单元格，直接存储内容
        rowData[`col_${i}`] = cellContent
      }
    }

    return rowData
  })
}

/**
 * 计算列宽度
 * @param content 列内容
 * @returns 列宽度
 */
function calculateColumnWidth(content: string): number {
  if (!content) return 100

  // 基础宽度
  let width = 80

  // 根据内容长度调整宽度
  const contentLength = content.length
  if (contentLength <= 4) {
    width = 80
  } else if (contentLength <= 8) {
    width = 120
  } else if (contentLength <= 12) {
    width = 160
  } else {
    width = Math.min(200, contentLength * 12)
  }

  return width
}

/**
 * 创建示例表格数据
 * @returns 示例表格数据
 */
export function createSampleTableData() {
  return [
    {
      id: 'sample_table_1',
      name: '示例表格',
      columns: [
        { prop: 'col_0', label: '姓名', width: 120, sortable: false, showOverflowTooltip: true, align: 'left' as const },
        { prop: 'col_1', label: '年龄', width: 80, sortable: true, showOverflowTooltip: true, align: 'center' as const },
        { prop: 'col_2', label: '部门', width: 150, sortable: false, showOverflowTooltip: true, align: 'left' as const },
        { prop: 'col_3', label: '职位', width: 150, sortable: false, showOverflowTooltip: true, align: 'left' as const }
      ],
      tableData: [
        { id: 'row_0', col_0: '张三', col_1: 25, col_2: '技术部', col_3: '前端工程师' },
        { id: 'row_1', col_0: '李四', col_1: 30, col_2: '产品部', col_3: '产品经理' },
        { id: 'row_2', col_0: '王五', col_1: 28, col_2: '设计部', col_3: 'UI设计师' },
        { id: 'row_3', col_0: '赵六', col_1: 32, col_2: '技术部', col_3: '后端工程师' }
      ],
      border: true,
      stripe: true,
      size: 'default',
      showHeader: true,
      highlightCurrentRow: true,
      emptyText: '暂无数据',
      showSummary: false,
      width: 600,
      height: 300
    }
  ]
}
